home *** CD-ROM | disk | FTP | other *** search
/ EuroCD 3 / EuroCD 3.iso / Games / Doom / ADoom-0.8 / ADoom_src / r_things.c < prev    next >
C/C++ Source or Header  |  1998-06-24  |  21KB  |  1,009 lines
  1. // Emacs style mode select   -*- C++ -*- 
  2. //-----------------------------------------------------------------------------
  3. //
  4. // $Id:$
  5. //
  6. // Copyright (C) 1993-1996 by id Software, Inc.
  7. //
  8. // This source is available for distribution and/or modification
  9. // only under the terms of the DOOM Source Code License as
  10. // published by id Software. All rights reserved.
  11. //
  12. // The source is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
  15. // for more details.
  16. //
  17. // $Log:$
  18. //
  19. // DESCRIPTION:
  20. //    Refresh of things, i.e. objects represented by sprites.
  21. //
  22. //-----------------------------------------------------------------------------
  23.  
  24.  
  25. static const char
  26. rcsid[] = "$Id: r_things.c,v 1.5 1997/02/03 16:47:56 b1 Exp $";
  27.  
  28.  
  29. #include <stdio.h>
  30. #include <stdlib.h>
  31.  
  32.  
  33. #include "doomdef.h"
  34. #include "m_swap.h"
  35.  
  36. #include "i_system.h"
  37. #include "z_zone.h"
  38. #include "w_wad.h"
  39.  
  40. #include "r_local.h"
  41.  
  42. #include "doomstat.h"
  43.  
  44.  
  45.  
  46. #define MINZ                (FRACUNIT*4)
  47. #define BASEYCENTER            100
  48.  
  49. //void R_DrawColumn (void);
  50. //void R_DrawFuzzColumn (void);
  51.  
  52.  
  53.  
  54. typedef struct
  55. {
  56.     int        x1;
  57.     int        x2;
  58.     
  59.     int        column;
  60.     int        topclip;
  61.     int        bottomclip;
  62.  
  63. } maskdraw_t;
  64.  
  65.  
  66.  
  67. //
  68. // Sprite rotation 0 is facing the viewer,
  69. //  rotation 1 is one angle turn CLOCKWISE around the axis.
  70. // This is not the same as the angle,
  71. //  which increases counter clockwise (protractor).
  72. // There was a lot of stuff grabbed wrong, so I changed it...
  73. //
  74. fixed_t        pspritescale;
  75. fixed_t        pspriteiscale;
  76.  
  77. lighttable_t**    spritelights;
  78.  
  79. // constant arrays
  80. //  used for psprite clipping and initializing clipping
  81. short        negonearray[SCREENWIDTH];
  82. short        screenheightarray[SCREENWIDTH];
  83.  
  84.  
  85. //
  86. // INITIALIZATION FUNCTIONS
  87. //
  88.  
  89. // variables used to look up
  90. //  and range check thing_t sprites patches
  91. spritedef_t*    sprites;
  92. int        numsprites;
  93.  
  94. FAR spriteframe_t    sprtemp[29];
  95. int        maxframe;
  96. char*        spritename;
  97.  
  98.  
  99.  
  100.  
  101. //
  102. // R_InstallSpriteLump
  103. // Local function for R_InitSprites.
  104. //
  105. void
  106. R_InstallSpriteLump
  107. ( int        lump,
  108.   unsigned    frame,
  109.   unsigned    rotation,
  110.   boolean    flipped )
  111. {
  112.     int        r;
  113.     
  114.     if (frame >= 29 || rotation > 8)
  115.     I_Error("R_InstallSpriteLump: "
  116.         "Bad frame characters in lump %i", lump);
  117.     
  118.     if ((int)frame > maxframe)
  119.     maxframe = frame;
  120.         
  121.     if (rotation == 0)
  122.     {
  123.     // the lump should be used for all rotations
  124.     if (sprtemp[frame].rotate == false)
  125.         I_Error ("R_InitSprites: Sprite %s frame %c has "
  126.              "multip rot=0 lump", spritename, 'A'+frame);
  127.  
  128.     if (sprtemp[frame].rotate == true)
  129.         I_Error ("R_InitSprites: Sprite %s frame %c has rotations "
  130.              "and a rot=0 lump", spritename, 'A'+frame);
  131.             
  132.     sprtemp[frame].rotate = false;
  133.     for (r=0 ; r<8 ; r++)
  134.     {
  135.         sprtemp[frame].lump[r] = lump - firstspritelump;
  136.         sprtemp[frame].flip[r] = (byte)flipped;
  137.     }
  138.     return;
  139.     }
  140.     
  141.     // the lump is only used for one rotation
  142.     if (sprtemp[frame].rotate == false)
  143.     I_Error ("R_InitSprites: Sprite %s frame %c has rotations "
  144.          "and a rot=0 lump", spritename, 'A'+frame);
  145.         
  146.     sprtemp[frame].rotate = true;
  147.  
  148.     // make 0 based
  149.     rotation--;        
  150.     if (sprtemp[frame].lump[rotation] != -1)
  151.     I_Error ("R_InitSprites: Sprite %s : %c : %c "
  152.          "has two lumps mapped to it",
  153.          spritename, 'A'+frame, '1'+rotation);
  154.         
  155.     sprtemp[frame].lump[rotation] = lump - firstspritelump;
  156.     sprtemp[frame].flip[rotation] = (byte)flipped;
  157. }
  158.  
  159.  
  160.  
  161.  
  162. //
  163. // R_InitSpriteDefs
  164. // Pass a null terminated list of sprite names
  165. //  (4 chars exactly) to be used.
  166. // Builds the sprite rotation matrixes to account
  167. //  for horizontally flipped sprites.
  168. // Will report an error if the lumps are inconsistant. 
  169. // Only called at startup.
  170. //
  171. // Sprite lump names are 4 characters for the actor,
  172. //  a letter for the frame, and a number for the rotation.
  173. // A sprite that is flippable will have an additional
  174. //  letter/number appended.
  175. // The rotation character can be 0 to signify no rotations.
  176. //
  177. void R_InitSpriteDefs (char** namelist) 
  178. { 
  179.     char**    check;
  180.     int        i;
  181.     int        l;
  182.     int        intname;
  183.     int        frame;
  184.     int        rotation;
  185.     int        start;
  186.     int        end;
  187.     int        patched;
  188.         
  189.     // count the number of sprite names
  190.     check = namelist;
  191.     while (*check != NULL)
  192.     check++;
  193.  
  194.     numsprites = check-namelist;
  195.     
  196.     if (!numsprites)
  197.     return;
  198.         
  199.     sprites = Z_Malloc(numsprites *sizeof(*sprites), PU_STATIC, NULL);
  200.     
  201.     start = firstspritelump-1;
  202.     end = lastspritelump+1;
  203.     
  204.     // scan all the lump names for each of the names,
  205.     //  noting the highest frame letter.
  206.     // Just compare 4 characters as ints
  207.     for (i=0 ; i<numsprites ; i++)
  208.     {
  209.     spritename = namelist[i];
  210.     memset (sprtemp,-1, sizeof(sprtemp));
  211.         
  212.     maxframe = -1;
  213.     intname = *(int *)namelist[i];
  214.     
  215.     // scan the lumps,
  216.     //  filling in the frames for whatever is found
  217.     for (l=start+1 ; l<end ; l++)
  218.     {
  219.         if (*(int *)lumpinfo[l].name == intname)
  220.         {
  221.         frame = lumpinfo[l].name[4] - 'A';
  222.         rotation = lumpinfo[l].name[5] - '0';
  223.  
  224.         if (modifiedgame)
  225.             patched = W_GetNumForName (lumpinfo[l].name);
  226.         else
  227.             patched = l;
  228.  
  229.         R_InstallSpriteLump (patched, frame, rotation, false);
  230.  
  231.         if (lumpinfo[l].name[6])
  232.         {
  233.             frame = lumpinfo[l].name[6] - 'A';
  234.             rotation = lumpinfo[l].name[7] - '0';
  235.             R_InstallSpriteLump (l, frame, rotation, true);
  236.         }
  237.         }
  238.     }
  239.     
  240.     // check the frames that were found for completeness
  241.     if (maxframe == -1)
  242.     {
  243.         sprites[i].numframes = 0;
  244.         continue;
  245.     }
  246.         
  247.     maxframe++;
  248.     
  249.     for (frame = 0 ; frame < maxframe ; frame++)
  250.     {
  251.         switch ((int)sprtemp[frame].rotate)
  252.         {
  253.           case -1:
  254.         // no rotations were found for that frame at all
  255.         I_Error ("R_InitSprites: No patches found "
  256.              "for %s frame %c", namelist[i], frame+'A');
  257.         break;
  258.         
  259.           case 0:
  260.         // only the first rotation is needed
  261.         break;
  262.             
  263.           case 1:
  264.         // must have all 8 frames
  265.         for (rotation=0 ; rotation<8 ; rotation++)
  266.             if (sprtemp[frame].lump[rotation] == -1)
  267.             I_Error ("R_InitSprites: Sprite %s frame %c "
  268.                  "is missing rotations",
  269.                  namelist[i], frame+'A');
  270.         break;
  271.         }
  272.     }
  273.     
  274.     // allocate space for the frames present and copy sprtemp to it
  275.     sprites[i].numframes = maxframe;
  276.     sprites[i].spriteframes = 
  277.         Z_Malloc (maxframe * sizeof(spriteframe_t), PU_STATIC, NULL);
  278.     memcpy (sprites[i].spriteframes, sprtemp, maxframe*sizeof(spriteframe_t));
  279.     }
  280.  
  281. }
  282.  
  283.  
  284.  
  285.  
  286. //
  287. // GAME FUNCTIONS
  288. //
  289. FAR vissprite_t    vissprites[MAXVISSPRITES];
  290. vissprite_t*    vissprite_p;
  291. int        newvissprite;
  292.  
  293.  
  294.  
  295. //
  296. // R_InitSprites
  297. // Called at program start.
  298. //
  299. void R_InitSprites (char** namelist)
  300. {
  301.     int        i;
  302.     
  303.     for (i=0 ; i<SCREENWIDTH ; i++)
  304.     {
  305.     negonearray[i] = -1;
  306.     }
  307.     
  308.     R_InitSpriteDefs (namelist);
  309. }
  310.  
  311.  
  312.  
  313. //
  314. // R_ClearSprites
  315. // Called at frame start.
  316. //
  317. void R_ClearSprites (void)
  318. {
  319.     vissprite_p = vissprites;
  320. }
  321.  
  322.  
  323. //
  324. // R_NewVisSprite
  325. //
  326. vissprite_t    overflowsprite;
  327.  
  328. vissprite_t* R_NewVisSprite (void)
  329. {
  330.     if (vissprite_p == &vissprites[MAXVISSPRITES])
  331.     return &overflowsprite;
  332.     
  333.     vissprite_p++;
  334.     return vissprite_p-1;
  335. }
  336.  
  337.  
  338.  
  339. //
  340. // R_DrawMaskedColumn
  341. // Used for sprites and masked mid textures.
  342. // Masked means: partly transparent, i.e. stored
  343. //  in posts/runs of opaque pixels.
  344. //
  345. short*        mfloorclip;
  346. short*        mceilingclip;
  347.  
  348. fixed_t        spryscale;
  349. fixed_t        sprtopscreen;
  350.  
  351. //#ifndef AMIGA
  352. void R_DrawMaskedColumn (column_t* column)
  353. {
  354.     int        topscreen;
  355.     int     bottomscreen;
  356.     fixed_t    basetexturemid;
  357.     
  358.     basetexturemid = dc_texturemid;
  359.     
  360.     for ( ; column->topdelta != 0xff ; ) 
  361.     {
  362.     // calculate unclipped screen coordinates
  363.     //  for post
  364.     topscreen = sprtopscreen + spryscale*column->topdelta;
  365.     bottomscreen = topscreen + spryscale*column->length;
  366.  
  367.     dc_yl = (topscreen+FRACUNIT-1)>>FRACBITS;
  368.     dc_yh = (bottomscreen-1)>>FRACBITS;
  369.         
  370.     if (dc_yh >= mfloorclip[dc_x])
  371.         dc_yh = mfloorclip[dc_x]-1;
  372.     if (dc_yl <= mceilingclip[dc_x])
  373.         dc_yl = mceilingclip[dc_x]+1;
  374.  
  375.     if (dc_yl <= dc_yh)
  376.     {
  377.         dc_source = (byte *)column + 3;
  378.         dc_texturemid = basetexturemid - (column->topdelta<<FRACBITS);
  379.         // dc_source = (byte *)column + 3 - column->topdelta;
  380.  
  381.         // Drawn by either R_DrawColumn
  382.         //  or (SHADOW) R_DrawFuzzColumn.
  383.         colfunc ();    
  384.     }
  385.     column = (column_t *)(  (byte *)column + column->length + 4);
  386.     }
  387.     
  388.     dc_texturemid = basetexturemid;
  389. }
  390. //#endif
  391.  
  392.  
  393.  
  394. //
  395. // R_DrawVisSprite
  396. //  mfloorclip and mceilingclip should also be set.
  397. //
  398. void
  399. R_DrawVisSprite
  400. ( vissprite_t*        vis,
  401.   int            x1,
  402.   int            x2 )
  403. {
  404.     column_t*        column;
  405.     int            texturecolumn;
  406.     fixed_t        frac;
  407.     patch_t*        patch;
  408.     
  409. //#ifdef AMIGA
  410. //    int            type = TYPE_NORMAL;
  411. //#endif
  412.  
  413.     
  414.     patch = W_CacheLumpNum (vis->patch+firstspritelump, PU_CACHE);
  415.  
  416.     dc_colormap = vis->colormap;
  417.     
  418.     if (!dc_colormap)
  419.     {
  420. //#ifndef AMIGA
  421.     // NULL colormap = shadow draw
  422.     colfunc = fuzzcolfunc;
  423. //#else
  424. //        type = TYPE_FUZZ;
  425. //#endif
  426.     }
  427.     else if (vis->mobjflags & MF_TRANSLATION)
  428.     {
  429. //#ifndef AMIGA
  430.     colfunc = transcolfunc;
  431. //#else
  432. //        type = TYPE_TRANSL;
  433. //#endif
  434.     dc_translation = translationtables - 256 +
  435.         ( (vis->mobjflags & MF_TRANSLATION) >> (MF_TRANSSHIFT-8) );
  436.     }
  437.     
  438.     dc_iscale = iabs(vis->xiscale)>>detailshift;
  439.     dc_texturemid = vis->texturemid;
  440.     frac = vis->startfrac;
  441.     spryscale = vis->scale;
  442.     sprtopscreen = centeryfrac - FixedMul(dc_texturemid,spryscale);
  443.     
  444.     for (dc_x=vis->x1 ; dc_x<=vis->x2 ; dc_x++, frac += vis->xiscale)
  445.     {
  446.     texturecolumn = frac>>FRACBITS;
  447. #ifdef RANGECHECK
  448.     if (texturecolumn < 0 || texturecolumn >= SHORT(patch->width))
  449.         I_Error ("R_DrawSpriteRange: bad texturecolumn");
  450. #endif
  451.     column = (column_t *) ((byte *)patch +
  452.                    LONG(patch->columnofs[texturecolumn]));
  453.  
  454. //#ifndef AMIGA
  455.      R_DrawMaskedColumn (column);
  456. //#else
  457. //    R_DrawMaskedColumnAmi (column, type);
  458. //#endif
  459.     }
  460.  
  461.     colfunc = basecolfunc;
  462. }
  463.  
  464.  
  465.  
  466. //
  467. // R_ProjectSprite
  468. // Generates a vissprite for a thing
  469. //  if it might be visible.
  470. //
  471. void R_ProjectSprite (mobj_t* thing)
  472. {
  473.     fixed_t        tr_x;
  474.     fixed_t        tr_y;
  475.     
  476.     fixed_t        gxt;
  477.     fixed_t        gyt;
  478.     
  479.     fixed_t        tx;
  480.     fixed_t        tz;
  481.  
  482.     fixed_t        xscale;
  483.     
  484.     int            x1;
  485.     int            x2;
  486.  
  487.     spritedef_t*    sprdef;
  488.     spriteframe_t*    sprframe;
  489.     int            lump;
  490.     
  491.     unsigned        rot;
  492.     boolean        flip;
  493.     
  494.     int            index;
  495.  
  496.     vissprite_t*    vis;
  497.     
  498.     angle_t        ang;
  499.     fixed_t        iscale;
  500.     
  501.     // transform the origin point
  502.     tr_x = thing->x - viewx;
  503.     tr_y = thing->y - viewy;
  504.     
  505.     gxt = FixedMul(tr_x,viewcos); 
  506.     gyt = -FixedMul(tr_y,viewsin);
  507.     
  508.     tz = gxt-gyt; 
  509.  
  510.     // thing is behind view plane?
  511.     if (tz < MINZ)
  512.     return;
  513.     
  514.     xscale = FixedDiv(projection, tz);
  515.     
  516.     gxt = -FixedMul(tr_x,viewsin); 
  517.     gyt = FixedMul(tr_y,viewcos); 
  518.     tx = -(gyt+gxt); 
  519.  
  520.     // too far off the side?
  521.     if (iabs(tx)>(tz<<2))
  522.     return;
  523.     
  524.     // decide which patch to use for sprite relative to player
  525. #ifdef RANGECHECK
  526.     if ((unsigned)thing->sprite >= numsprites)
  527.     I_Error ("R_ProjectSprite: invalid sprite number %i ",
  528.          thing->sprite);
  529. #endif
  530.     sprdef = &sprites[thing->sprite];
  531. #ifdef RANGECHECK
  532.     if ( (thing->frame&FF_FRAMEMASK) >= sprdef->numframes )
  533.     I_Error ("R_ProjectSprite: invalid sprite frame %i : %i ",
  534.          thing->sprite, thing->frame);
  535. #endif
  536.     sprframe = &sprdef->spriteframes[ thing->frame & FF_FRAMEMASK];
  537.  
  538.     if (sprframe->rotate)
  539.     {
  540.     // choose a different rotation based on player view
  541.     ang = R_PointToAngle (thing->x, thing->y);
  542.     rot = (ang-thing->angle+(unsigned)(ANG45/2)*9)>>29;
  543.     lump = sprframe->lump[rot];
  544.     flip = (boolean)sprframe->flip[rot];
  545.     }
  546.     else
  547.     {
  548.     // use single rotation for all views
  549.     lump = sprframe->lump[0];
  550.     flip = (boolean)sprframe->flip[0];
  551.     }
  552.     
  553.     // calculate edges of the shape
  554.     tx -= spriteoffset[lump];    
  555.     x1 = (centerxfrac + FixedMul (tx,xscale) ) >>FRACBITS;
  556.  
  557.     // off the right side?
  558.     if (x1 > viewwidth)
  559.     return;
  560.     
  561.     tx +=  spritewidth[lump];
  562.     x2 = ((centerxfrac + FixedMul (tx,xscale) ) >>FRACBITS) - 1;
  563.  
  564.     // off the left side
  565.     if (x2 < 0)
  566.     return;
  567.     
  568.     // store information in a vissprite
  569.     vis = R_NewVisSprite ();
  570.     vis->mobjflags = thing->flags;
  571.     vis->scale = xscale<<detailshift;
  572.     vis->gx = thing->x;
  573.     vis->gy = thing->y;
  574.     vis->gz = thing->z;
  575.     vis->gzt = thing->z + spritetopoffset[lump];
  576.     vis->texturemid = vis->gzt - viewz;
  577.     vis->x1 = x1 < 0 ? 0 : x1;
  578.     vis->x2 = x2 >= viewwidth ? viewwidth-1 : x2;    
  579.     iscale = FixedDiv (FRACUNIT, xscale);
  580.  
  581.     if (flip)
  582.     {
  583.     vis->startfrac = spritewidth[lump]-1;
  584.     vis->xiscale = -iscale;
  585.     }
  586.     else
  587.     {
  588.     vis->startfrac = 0;
  589.     vis->xiscale = iscale;
  590.     }
  591.  
  592.     if (vis->x1 > x1)
  593.     vis->startfrac += vis->xiscale*(vis->x1-x1);
  594.     vis->patch = lump;
  595.     
  596.     // get light level
  597.     if (thing->flags & MF_SHADOW)
  598.     {
  599.     // shadow draw
  600.     vis->colormap = NULL;
  601.     }
  602.     else if (fixedcolormap)
  603.     {
  604.     // fixed map
  605.     vis->colormap = fixedcolormap;
  606.     }
  607.     else if (thing->frame & FF_FULLBRIGHT)
  608.     {
  609.     // full bright
  610.     vis->colormap = colormaps;
  611.     }
  612.     
  613.     else
  614.     {
  615.     // diminished light
  616.     index = xscale>>(LIGHTSCALESHIFT-detailshift);
  617.  
  618.     if (index >= MAXLIGHTSCALE) 
  619.         index = MAXLIGHTSCALE-1;
  620.  
  621.     vis->colormap = spritelights[index];
  622.     }    
  623. }
  624.  
  625.  
  626.  
  627.  
  628. //
  629. // R_AddSprites
  630. // During BSP traversal, this adds sprites by sector.
  631. //
  632. void R_AddSprites (sector_t* sec)
  633. {
  634.     mobj_t*        thing;
  635.     int            lightnum;
  636.  
  637.     // BSP is traversed by subsector.
  638.     // A sector might have been split into several
  639.     //  subsectors during BSP building.
  640.     // Thus we check whether its already added.
  641.     if (sec->validcount == validcount)
  642.     return;        
  643.  
  644.     // Well, now it will be done.
  645.     sec->validcount = validcount;
  646.     
  647.     lightnum = (sec->lightlevel >> LIGHTSEGSHIFT)+extralight;
  648.  
  649.     if (lightnum < 0)        
  650.     spritelights = scalelight[0];
  651.     else if (lightnum >= LIGHTLEVELS)
  652.     spritelights = scalelight[LIGHTLEVELS-1];
  653.     else
  654.     spritelights = scalelight[lightnum];
  655.  
  656.     // Handle all things in sector.
  657.     for (thing = sec->thinglist ; thing ; thing = thing->snext)
  658.     R_ProjectSprite (thing);
  659. }
  660.  
  661.  
  662. //
  663. // R_DrawPSprite
  664. //
  665. void R_DrawPSprite (pspdef_t* psp)
  666. {
  667.     fixed_t        tx;
  668.     int            x1;
  669.     int            x2;
  670.     spritedef_t*    sprdef;
  671.     spriteframe_t*    sprframe;
  672.     int            lump;
  673.     boolean        flip;
  674.     vissprite_t*    vis;
  675.     vissprite_t        avis;
  676.     
  677.     // decide which patch to use
  678. #ifdef RANGECHECK
  679.     if ( (unsigned)psp->state->sprite >= numsprites)
  680.     I_Error ("R_ProjectSprite: invalid sprite number %i ",
  681.          psp->state->sprite);
  682. #endif
  683.     sprdef = &sprites[psp->state->sprite];
  684. #ifdef RANGECHECK
  685.     if ( (psp->state->frame & FF_FRAMEMASK)  >= sprdef->numframes)
  686.     I_Error ("R_ProjectSprite: invalid sprite frame %i : %i ",
  687.          psp->state->sprite, psp->state->frame);
  688. #endif
  689.     sprframe = &sprdef->spriteframes[ psp->state->frame & FF_FRAMEMASK ];
  690.  
  691.     lump = sprframe->lump[0];
  692.     flip = (boolean)sprframe->flip[0];
  693.     
  694.     // calculate edges of the shape
  695.     tx = psp->sx-160*FRACUNIT;
  696.     
  697.     tx -= spriteoffset[lump];    
  698.     x1 = (centerxfrac + FixedMul (tx,pspritescale) ) >>FRACBITS;
  699.  
  700.     // off the right side
  701.     if (x1 > viewwidth)
  702.     return;        
  703.  
  704.     tx +=  spritewidth[lump];
  705.     x2 = ((centerxfrac + FixedMul (tx, pspritescale) ) >>FRACBITS) - 1;
  706.  
  707.     // off the left side
  708.     if (x2 < 0)
  709.     return;
  710.     
  711.     // store information in a vissprite
  712.     vis = &avis;
  713.     vis->mobjflags = 0;
  714.     vis->texturemid = (BASEYCENTER<<FRACBITS)+FRACUNIT/2-(psp->sy-spritetopoffset[lump]);
  715.     vis->x1 = x1 < 0 ? 0 : x1;
  716.     vis->x2 = x2 >= viewwidth ? viewwidth-1 : x2;    
  717.     vis->scale = pspritescale<<detailshift;
  718.     
  719.     if (flip)
  720.     {
  721.     vis->xiscale = -pspriteiscale;
  722.     vis->startfrac = spritewidth[lump]-1;
  723.     }
  724.     else
  725.     {
  726.     vis->xiscale = pspriteiscale;
  727.     vis->startfrac = 0;
  728.     }
  729.     
  730.     if (vis->x1 > x1)
  731.     vis->startfrac += vis->xiscale*(vis->x1-x1);
  732.  
  733.     vis->patch = lump;
  734.  
  735.     if (viewplayer->powers[pw_invisibility] > 4*32
  736.     || viewplayer->powers[pw_invisibility] & 8)
  737.     {
  738.     // shadow draw
  739.     vis->colormap = NULL;
  740.     }
  741.     else if (fixedcolormap)
  742.     {
  743.     // fixed color
  744.     vis->colormap = fixedcolormap;
  745.     }
  746.     else if (psp->state->frame & FF_FULLBRIGHT)
  747.     {
  748.     // full bright
  749.     vis->colormap = colormaps;
  750.     }
  751.     else
  752.     {
  753.     // local light
  754.     vis->colormap = spritelights[MAXLIGHTSCALE-1];
  755.     }
  756.     
  757.     R_DrawVisSprite (vis, vis->x1, vis->x2);
  758. }
  759.  
  760.  
  761.  
  762. //
  763. // R_DrawPlayerSprites
  764. //
  765. void R_DrawPlayerSprites (void)
  766. {
  767.     int        i;
  768.     int        lightnum;
  769.     pspdef_t*    psp;
  770.     
  771.     // get light level
  772.     lightnum =
  773.     (viewplayer->mo->subsector->sector->lightlevel >> LIGHTSEGSHIFT) 
  774.     +extralight;
  775.  
  776.     if (lightnum < 0)        
  777.     spritelights = scalelight[0];
  778.     else if (lightnum >= LIGHTLEVELS)
  779.     spritelights = scalelight[LIGHTLEVELS-1];
  780.     else
  781.     spritelights = scalelight[lightnum];
  782.     
  783.     // clip to screen bounds
  784.     mfloorclip = screenheightarray;
  785.     mceilingclip = negonearray;
  786.     
  787.     // add all active psprites
  788.     for (i=0, psp=viewplayer->psprites;
  789.      i<NUMPSPRITES;
  790.      i++,psp++)
  791.     {
  792.     if (psp->state)
  793.         R_DrawPSprite (psp);
  794.     }
  795. }
  796.  
  797.  
  798.  
  799.  
  800. //
  801. // R_SortVisSprites
  802. //
  803. vissprite_t    vsprsortedhead;
  804.  
  805.  
  806. void R_SortVisSprites (void)
  807. {
  808.     int            i;
  809.     int            count;
  810.     vissprite_t*    ds;
  811.     vissprite_t*    best;
  812.     vissprite_t        unsorted;
  813.     fixed_t        bestscale;
  814.  
  815.     count = vissprite_p - vissprites;
  816.     
  817.     unsorted.next = unsorted.prev = &unsorted;
  818.  
  819.     if (!count)
  820.     return;
  821.         
  822.     for (ds=vissprites ; ds<vissprite_p ; ds++)
  823.     {
  824.     ds->next = ds+1;
  825.     ds->prev = ds-1;
  826.     }
  827.     
  828.     vissprites[0].prev = &unsorted;
  829.     unsorted.next = &vissprites[0];
  830.     (vissprite_p-1)->next = &unsorted;
  831.     unsorted.prev = vissprite_p-1;
  832.     
  833.     // pull the vissprites out by scale
  834.     //best = 0;        // shut up the compiler warning
  835.     vsprsortedhead.next = vsprsortedhead.prev = &vsprsortedhead;
  836.     for (i=0 ; i<count ; i++)
  837.     {
  838.     bestscale = MAXINT;
  839.     for (ds=unsorted.next ; ds!= &unsorted ; ds=ds->next)
  840.     {
  841.         if (ds->scale < bestscale)
  842.         {
  843.         bestscale = ds->scale;
  844.         best = ds;
  845.         }
  846.     }
  847.     best->next->prev = best->prev;
  848.     best->prev->next = best->next;
  849.     best->next = &vsprsortedhead;
  850.     best->prev = vsprsortedhead.prev;
  851.     vsprsortedhead.prev->next = best;
  852.     vsprsortedhead.prev = best;
  853.     }
  854. }
  855.  
  856.  
  857.  
  858. //
  859. // R_DrawSprite
  860. //
  861. void R_DrawSprite (vissprite_t* spr)
  862. {
  863.     drawseg_t*        ds;
  864.     short        clipbot[SCREENWIDTH];
  865.     short        cliptop[SCREENWIDTH];
  866.     int            x;
  867.     int            r1;
  868.     int            r2;
  869.     fixed_t        scale;
  870.     fixed_t        lowscale;
  871.     int            silhouette;
  872.         
  873.     for (x = spr->x1 ; x<=spr->x2 ; x++)
  874.     clipbot[x] = cliptop[x] = -2;
  875.     
  876.     // Scan drawsegs from end to start for obscuring segs.
  877.     // The first drawseg that has a greater scale
  878.     //  is the clip seg.
  879.     for (ds=ds_p-1 ; ds >= drawsegs ; ds--)
  880.     {
  881.     // determine if the drawseg obscures the sprite
  882.     if (ds->x1 > spr->x2
  883.         || ds->x2 < spr->x1
  884.         || (!ds->silhouette
  885.         && !ds->maskedtexturecol) )
  886.     {
  887.         // does not cover sprite
  888.         continue;
  889.     }
  890.             
  891.     r1 = ds->x1 < spr->x1 ? spr->x1 : ds->x1;
  892.     r2 = ds->x2 > spr->x2 ? spr->x2 : ds->x2;
  893.  
  894.     if (ds->scale1 > ds->scale2)
  895.     {
  896.         lowscale = ds->scale2;
  897.         scale = ds->scale1;
  898.     }
  899.     else
  900.     {
  901.         lowscale = ds->scale1;
  902.         scale = ds->scale2;
  903.     }
  904.         
  905.     if (scale < spr->scale
  906.         || ( lowscale < spr->scale
  907.          && !R_PointOnSegSide (spr->gx, spr->gy, ds->curline) ) )
  908.     {
  909.         // masked mid texture?
  910.         if (ds->maskedtexturecol)    
  911.         R_RenderMaskedSegRange (ds, r1, r2);
  912.         // seg is behind sprite
  913.         continue;            
  914.     }
  915.  
  916.     
  917.     // clip this piece of the sprite
  918.     silhouette = ds->silhouette;
  919.     
  920.     if (spr->gz >= ds->bsilheight)
  921.         silhouette &= ~SIL_BOTTOM;
  922.  
  923.     if (spr->gzt <= ds->tsilheight)
  924.         silhouette &= ~SIL_TOP;
  925.             
  926.     if (silhouette == 1)
  927.     {
  928.         // bottom sil
  929.         for (x=r1 ; x<=r2 ; x++)
  930.         if (clipbot[x] == -2)
  931.             clipbot[x] = ds->sprbottomclip[x];
  932.     }
  933.     else if (silhouette == 2)
  934.     {
  935.         // top sil
  936.         for (x=r1 ; x<=r2 ; x++)
  937.         if (cliptop[x] == -2)
  938.             cliptop[x] = ds->sprtopclip[x];
  939.     }
  940.     else if (silhouette == 3)
  941.     {
  942.         // both
  943.         for (x=r1 ; x<=r2 ; x++)
  944.         {
  945.         if (clipbot[x] == -2)
  946.             clipbot[x] = ds->sprbottomclip[x];
  947.         if (cliptop[x] == -2)
  948.             cliptop[x] = ds->sprtopclip[x];
  949.         }
  950.     }
  951.         
  952.     }
  953.     
  954.     // all clipping has been performed, so draw the sprite
  955.  
  956.     // check for unclipped columns
  957.     for (x = spr->x1 ; x<=spr->x2 ; x++)
  958.     {
  959.     if (clipbot[x] == -2)        
  960.         clipbot[x] = viewheight;
  961.  
  962.     if (cliptop[x] == -2)
  963.         cliptop[x] = -1;
  964.     }
  965.         
  966.     mfloorclip = clipbot;
  967.     mceilingclip = cliptop;
  968.     R_DrawVisSprite (spr, spr->x1, spr->x2);
  969. }
  970.  
  971.  
  972.  
  973.  
  974. //
  975. // R_DrawMasked
  976. //
  977. void R_DrawMasked (void)
  978. {
  979.     vissprite_t*    spr;
  980.     drawseg_t*        ds;
  981.     
  982.     R_SortVisSprites ();
  983.  
  984.     if (vissprite_p > vissprites)
  985.     {
  986.     // draw all vissprites back to front
  987.     for (spr = vsprsortedhead.next ;
  988.          spr != &vsprsortedhead ;
  989.          spr=spr->next)
  990.     {
  991.         
  992.         R_DrawSprite (spr);
  993.     }
  994.     }
  995.     
  996.     // render any remaining masked mid textures
  997.     for (ds=ds_p-1 ; ds >= drawsegs ; ds--)
  998.     if (ds->maskedtexturecol)
  999.         R_RenderMaskedSegRange (ds, ds->x1, ds->x2);
  1000.     
  1001.     // draw the psprites on top of everything
  1002.     //  but does not draw on side views
  1003.     if (!viewangleoffset)        
  1004.     R_DrawPlayerSprites ();
  1005. }
  1006.  
  1007.  
  1008.  
  1009.